
package ch.hearc.coursJava.kitBase.tools;

import junit.framework.Assert;

public class TabTools
	{

	/*------------------------------------------------------------------*\
	|*							Methodes Public							*|
	\*------------------------------------------------------------------*/

	/**
	 * Hyp : taille identique
	 */
	public static int[] add(int[] tab1, int[] tab2)
		{
		Assert.assertTrue(tab1.length == tab2.length);

		int[] tabResult = new int[tab2.length];

		for(int i = 0; i < tab2.length; i++)
			{
			tabResult[i] = tab2[i] + tab1[i];
			}

		return tabResult;
		}

	public static boolean isEgal(double[][] matriceSource, double[][] matriceClone, double epsilon)
		{

		if (matriceSource.length != matriceClone.length)
			{
			return false;
			}
		else
			{
			for(int i = 1; i <= matriceSource.length; i++)
				{
				if (!isEgal(matriceSource[i - 1], matriceClone[i - 1], epsilon)) { return false; }
				}

			return true;
			}
		}

	public static boolean isEgal(double[][] matriceSource, double[][] matriceClone)
		{
		return isEgal(matriceSource, matriceClone, 0);
		}

	public static boolean isEgal(double[] tab1, double[] tab2, double epsilon)
		{
		if (tab1.length != tab2.length)
			{
			return false;
			}
		else
			{
			for(int i = 1; i <= tab1.length; i++)
				{
				if (!NombreTools.isEgal(tab1[i - 1], tab2[i - 1], epsilon)) { return false; }
				}
			return true;
			}
		}

	public static boolean isEgal(double[] tab1, double[] tab2)
		{
		return isEgal(tab1, tab2, 0);
		}

	public static double[][] cloner(double[][] matrixSource)
		{
		double[][] tabExt = new double[matrixSource.length][];
		int i = 1;

		for(double[] ligne:matrixSource)
			{
			tabExt[i - 1] = new double[ligne.length];
			transferer(tabExt[i - 1], ligne);
			i++;
			}
		return tabExt;
		}

	public static double[][] additionner(double[][] tab1, double[][] tab2)
		{
		double[][] tab = creerManuel(tab1.length, tab1[0].length);

		for(int i = 1; i <= tab1.length; i++)
			{
			for(int j = 1; j <= tab1[i].length; j++)
				{
				tab[i - 1][j - 1] = tab1[i - 1][j - 1] + tab2[i - 1][j - 1];
				}
			}

		return tab;
		}

	/**
	 * hyp: nombre de colonnes matrice 1 == nombre de lignes matrice 2
	 */
	public static double[][] produit(double[][] matrice1, double[][] matrice2)
		{
		Assert.assertTrue(matrice1[0].length == matrice2.length);

		double[][] matriceProduit = creer(matrice1.length, matrice2[0].length);

		for(int i = 1; i <= matrice1.length; i++)
			{
			for(int j = 1; j <= matrice2[0].length; j++)
				{
				matriceProduit[i - 1][j - 1] = 0;
				for(int k = 1; k <= matrice1[0].length; k++)
					{
					matriceProduit[i - 1][j - 1] += matrice1[i - 1][k - 1] * matrice2[k - 1][j - 1];
					}
				}
			}

		return matriceProduit;
		}

	/**
	 * syntaxe simplifier
	 */
	public static double[][] creer(int n, int m)
		{
		return new double[n][m];
		}

	public static double[][] creer(int[] tabNbColonneParLigne)
		{
		double[][] tabIrregulier = new double[tabNbColonneParLigne.length][];

		for(int i = 1; i <= tabIrregulier.length; i++)
			{
			tabIrregulier[i - 1] = new double[tabNbColonneParLigne[i - 1]];
			}
		return tabIrregulier;
		}

	public static double[][] creerManuel(int n, int m)
		{
		double[][] tableauExterieur = new double[n][];

		for(int i = 1; i <= n; i++)
			{
			tableauExterieur[i - 1] = new double[m];
			}

		return tableauExterieur;
		}

	public static double[][] creer(int n)
		{
		double[][] tabTriangulaire = new double[n][];

		for(int i = 1; i <= tabTriangulaire.length; i++)
			{
			tabTriangulaire[i - 1] = new double[i];
			}
		return tabTriangulaire;
		}

	public static void afficher(double[][] tab)
		{
		for(double[] ligne:tab)
			{
			for(double elemIJ:ligne)
				{
				System.out.print(elemIJ + "\t");
				}
			System.out.print("\n");
			}
		}

	public static void afficher(int[] tab)
		{
		for(int elemI:tab)
			{
			System.out.println(elemI);
			}
		}


	public static void afficher(double[] tab)
		{
		for(double elemI:tab)
			{
			System.out.println(elemI);
			}
		}

	public static <T> void afficher(T[] tab)
		{
		for(T elemI:tab)
			{
			System.out.println(elemI);
			}
		}

	/*------------------------------------------------------------------*\
	|*							Methodes Private						*|
	\*------------------------------------------------------------------*/

	/**
	 * Hyp: meme tailles
	 */
	private static void transferer(double[] tabDestination, double[] tabSource)
		{
		Assert.assertTrue(tabDestination.length == tabSource.length);

		for(int i = 1; i <= tabSource.length; i++)
			{
			tabDestination[i - 1] = tabSource[i - 1];
			}
		}
	}
